"""
文档解析器主类
统一管理各种文档格式的解析
"""

import os
import logging
from typing import Dict, Any, Optional
from .text_parser import TextParser
from .pdf_parser import PDFParser
from .docx_parser import DocxParser

logger = logging.getLogger(__name__)


class DocumentParser:
    """文档解析器主类"""
    
    def __init__(self):
        # 初始化各种解析器
        self.parsers = {
            '.txt': TextParser(),
            '.md': TextParser(),
            '.pdf': PDFParser(),
            '.docx': DocxParser(),
            '.doc': DocxParser()  # .doc文件也尝试用docx解析器
        }
        
        # 支持的文件扩展名
        self.supported_extensions = list(self.parsers.keys())
    
    def parse_file_content(self, content: bytes, file_ext: str) -> str:
        """解析文件内容，统一入口"""
        try:
            logger.info(f"开始解析文件，类型: {file_ext}, 大小: {len(content)} 字节")
            
            # 检查文件类型是否支持
            if file_ext.lower() not in self.supported_extensions:
                raise ValueError(f"不支持的文件类型: {file_ext}")
            
            # 获取对应的解析器
            parser = self.parsers.get(file_ext.lower())
            if not parser:
                raise ValueError(f"未找到适合的解析器: {file_ext}")
            
            # 解析文档内容
            if file_ext.lower() == '.md':
                # Markdown文件特殊处理
                parsed_text = parser.parse_markdown(content)
            else:
                parsed_text = parser.parse_content(content)
            
            logger.info(f"文档解析完成，提取内容长度: {len(parsed_text)} 字符")
            
            # 如果解析结果为空，返回默认内容
            if not parsed_text.strip():
                return f"{file_ext}文档解析完成，请在需求描述中补充具体信息"
            
            return parsed_text
            
        except Exception as e:
            logger.error(f"解析文件失败: {str(e)}")
            return "文档解析失败，请检查文件格式或手动输入需求描述"
    
    def get_file_info(self, content: bytes, file_ext: str) -> Dict[str, Any]:
        """获取文件信息"""
        info = {
            "file_type": file_ext,
            "file_size": len(content),
            "supported": file_ext.lower() in self.supported_extensions
        }
        
        try:
            parser = self.parsers.get(file_ext.lower())
            if parser:
                # 获取特定解析器的详细信息
                if hasattr(parser, 'get_pdf_info') and file_ext.lower() == '.pdf':
                    pdf_info = parser.get_pdf_info(content)
                    info.update(pdf_info)
                elif hasattr(parser, 'get_document_info') and file_ext.lower() in ['.docx', '.doc']:
                    doc_info = parser.get_document_info(content)
                    info.update(doc_info)
        
        except Exception as e:
            logger.warning(f"获取文件信息失败: {str(e)}")
        
        return info
    
    def validate_file(self, content: bytes, file_ext: str, filename: str = "") -> Dict[str, Any]:
        """验证文件"""
        validation_result = {
            "valid": True,
            "errors": [],
            "warnings": [],
            "info": {}
        }
        
        try:
            # 检查文件大小
            max_size = 50 * 1024 * 1024  # 50MB
            if len(content) > max_size:
                validation_result["valid"] = False
                validation_result["errors"].append(f"文件大小超过限制（{max_size // (1024*1024)}MB）")
            
            # 检查文件类型
            if file_ext.lower() not in self.supported_extensions:
                validation_result["valid"] = False
                validation_result["errors"].append(f"不支持的文件类型: {file_ext}")
            
            # 检查文件内容
            if len(content) == 0:
                validation_result["valid"] = False
                validation_result["errors"].append("文件内容为空")
            
            # 获取文件信息
            validation_result["info"] = self.get_file_info(content, file_ext)
            
            # 特定文件类型的验证
            if file_ext.lower() == '.pdf':
                pdf_info = validation_result["info"]
                if pdf_info.get("pages", 0) == 0:
                    validation_result["warnings"].append("PDF文件可能损坏或无法读取")
                elif not pdf_info.get("has_text", False):
                    validation_result["warnings"].append("PDF文件可能是扫描版，文本提取效果可能不佳")
            
            elif file_ext.lower() in ['.docx', '.doc']:
                doc_info = validation_result["info"]
                if doc_info.get("paragraphs", 0) == 0:
                    validation_result["warnings"].append("Word文档可能没有文本内容")
        
        except Exception as e:
            validation_result["valid"] = False
            validation_result["errors"].append(f"文件验证失败: {str(e)}")
        
        return validation_result
    
    def extract_requirements(self, content: bytes, file_ext: str) -> Dict[str, Any]:
        """提取需求信息"""
        try:
            # 解析文档内容
            parsed_content = self.parse_file_content(content, file_ext)
            
            # 获取对应的解析器
            parser = self.parsers.get(file_ext.lower())
            if not parser:
                return {"requirement": parsed_content}
            
            # 提取结构化信息
            result = {
                "requirement": parsed_content,
                "sections": parser.extract_sections(parsed_content),
                "flows": parser.extract_flows(parsed_content),
                "constraints": parser.extract_constraints(parsed_content)
            }
            
            # 尝试提取项目和模块名称
            project_name = self._extract_project_name(parsed_content)
            module_name = self._extract_module_name(parsed_content)
            
            if project_name:
                result["project_name"] = project_name
            if module_name:
                result["module_name"] = module_name
            
            return result
            
        except Exception as e:
            logger.error(f"提取需求信息失败: {str(e)}")
            return {"requirement": "需求信息提取失败"}
    
    def _extract_project_name(self, content: str) -> Optional[str]:
        """提取项目名称"""
        import re
        
        patterns = [
            r'项目[名称|名]\s*[:：]\s*(.+?)[\n\r]',
            r'项目[名称|名]\s*[:：]\s*(.+?)$',
            r'项目[:：]\s*(.+?)[\n\r]',
            r'系统[名称|名]\s*[:：]\s*(.+?)[\n\r]',
        ]
        
        for pattern in patterns:
            match = re.search(pattern, content, re.MULTILINE)
            if match:
                return match.group(1).strip()
        
        return None
    
    def _extract_module_name(self, content: str) -> Optional[str]:
        """提取模块名称"""
        import re
        
        patterns = [
            r'模块[名称|名]\s*[:：]\s*(.+?)[\n\r]',
            r'模块[:：]\s*(.+?)[\n\r]',
            r'功能模块\s*[:：]\s*(.+?)[\n\r]',
        ]
        
        for pattern in patterns:
            match = re.search(pattern, content, re.MULTILINE)
            if match:
                return match.group(1).strip()
        
        return None
    
    def get_supported_extensions(self) -> list:
        """获取支持的文件扩展名列表"""
        return self.supported_extensions.copy()
    
    def is_supported(self, file_ext: str) -> bool:
        """检查是否支持该文件类型"""
        return file_ext.lower() in self.supported_extensions
